package main

import (
	"fmt"
	"unsafe"
)

type Part1 struct {
	a bool
	b int32
	c int8
	d int64
	e byte
	f int
	g int64
	h bool
}

type s1 struct {
	f1 byte
	f2 bool
	f3 int16
}

type s2 struct {
	f1 byte
	f3 int16
	f2 bool
}

type student struct {
	id      int8     // 1 byte   0-3
	name    string   // 16 bytes  8-23
	classID int8     // 1 byte    24-24
	phone   [10]byte // 10 bytes   25-35
	address string   // 16 bytes    40-55
	grade   int32    // 4 bytes      56-60        64
}

type s4 struct {
	f1    byte
	f3    int16
	phone [4]byte
	f2    bool
}

type s5 struct {
	f1    byte
	phone [5]byte
	f3    int16
	f2    bool
}

//1.都是从0开始
//2.一般一次性取出四个字节
//3.开始对每一种类型计算其类型长度，unsafe.Alignof 来返回相应类型的对齐系数,unsafe.Sizeof类型长度
//4.开始对每一个对齐系数取模，位置从0开始，位置%对齐系数=0，即可
//5.若位置%对齐系数=0，则从此位置开始填充，填充类型长度
//若位置%对齐系数!=0，则，开辟出下一个四个字节，并用位置取模，一直到位置%对齐系数=0,填充类型长度个字节
//7.最后总体长度，应该是最大的对齐系数的倍数，可以理解为最终长度%最大对齐系统=0
//https://www.cnblogs.com/Kingram/p/14415938.html
//https://blog.huoding.com/2021/09/29/951

func main() {
	part1 := Part1{}

	fmt.Printf("part1 size: %d, align: %d\n", unsafe.Sizeof(part1), unsafe.Alignof(part1))
	s1 := s1{}
	fmt.Printf("s1 size: %d, align: %d\n", unsafe.Sizeof(s1), unsafe.Alignof(s1))
	s2 := s2{}
	fmt.Printf("s2 size: %d, align: %d\n", unsafe.Sizeof(s2), unsafe.Alignof(s2))

	fmt.Printf("string size:%d---string align: %d\n", unsafe.Sizeof(""), unsafe.Alignof(""))
	var f [10]byte
	fmt.Printf("[10]byte size:%d---[10]byte align: %d\n", unsafe.Sizeof(f), unsafe.Alignof(f))

	s3 := student{}
	fmt.Printf("s3 size: %d, align: %d\n", unsafe.Sizeof(s3), unsafe.Alignof(s3))

	fmt.Printf("%p\n", &s3.id)
	fmt.Printf("%p\n", &s3.name)
	fmt.Printf("%p\n", &s3.classID)
	fmt.Printf("%p\n", &s3.phone)
	fmt.Printf("%p\n", &s3.address)
	fmt.Printf("%p\n", &s3.grade)

	s4 := s4{}
	var g int32
	fmt.Printf("int16 size:%d---int16 align: %d\n", unsafe.Sizeof(g), unsafe.Alignof(g))
	fmt.Printf("s4 size: %d, align: %d\n", unsafe.Sizeof(s4), unsafe.Alignof(s4))

	s5 := s5{}
	fmt.Printf("s5 size: %d, align: %d\n", unsafe.Sizeof(s5), unsafe.Alignof(s5))

}
